Design and Fabrication

After many iterations and tests, I was able to visualize the final device. To translate the idea into a practical design, I first created a hand-drawn schematic to define the location of the main components, including the XIAO ESP32-C3 module, the flex sensors, the textile structure of the device, and the power supply system. For powering the device, I decided to use a power bank. As shown in the image below, this initial sketch helped me identify which parts would be made from textile materials and which parts would be manufactured using 3D printing. Once the concept was clearly defined on paper, I was able to begin the digital design process on the computer.

Digital Design

Using Fusion 360, I designed the structure that would hold the PCB and secure the device to the user's hand. As shown in the image, the design consists of three main parts: a cover, the enclosure that houses the fabricated circuit board, and an arch-shaped structure that functions as a clamp to secure the device to the forearm. Slots were also incorporated into the design to allow the installation of laser-cut straps, improving the overall attachment system. This approach enabled the integration of leather-like fabric and mesh textile materials with the 3D-printed plastic components, creating a more comfortable and adaptable wearable structure.

After completing the design of the enclosure that houses the PCB, I proceeded to develop the cutting patterns for the textile components of the device. These patterns define the fabric structure that supports the flex sensors and integrates the electronic system . The following images illustrate the design and arrangement of the textile parts before the fabrication process.

As shown in the image on the left, all measurements were taken directly from my hand, especially from the finger phalanges, since this is the area of greatest interest for the project. The length of each phalanx varies from one person to another, so these dimensions were customized to fit my hand. The width of each finger section was set to 25 mm because the textile components would be sewn together, requiring additional seam allowance to simplify the assembly process and improve the final fit of the device.

Once the cutting patterns and the enclosure for the PCB had been completed, I moved on to designing the electronic board using KiCad. The first version of the PCB was designed to connect two XIAO modules through UART communication. In the System Integration week, I explain in detail why I initially chose this approach, why I later decided to stop using it, and why the final version of the project only uses three flex sensors. Additionally, this first PCB design required jumper connections to distribute the GND signal across the board, which was another aspect that was improved in later revisions.

As a result, I redesigned the PCB to work with only three flex sensors, simplifying both the electronic system and the overall integration of the device. This modification reduced the complexity of the wiring, lowered the number of required components. The updated PCB design is shown below.

As shown in the image on the left, each flex sensor is connected using a voltage divider circuit with a fixed resistor value of 6.8 kΩ. This resistor value was selected based on the experiments and results obtained during the Input Devices week, where I explored the operation and characterization of flex sensors. If you are interested in learning more about the selection process and testing methodology, I invite you to review that documentation.

After completing the electronic design, I worked on the graphical user interface for the device. Using Qt Designer, I created the visual layout of the application and later programmed its functionality in Python. This interface allows communication with the wearable device, provides calibration controls, displays the detected gestures, and shows the translated words or letters generated by the system.

Additive Manufacturing

Once all the components had been designed, I moved on to the fabrication stage. I started with additive manufacturing by 3D printing the parts previously modeled in Fusion 360. For the printing parameters, I used a layer height of 0.24 mm and tree supports to reduce material consumption while providing adequate support for overhanging features.

Fabrication of Textile Components

Using computer-controlled cutting techniques, I began manufacturing the textile components of the device. The material selected for this stage was synthetic leather. The first step was preparing the cutting file and defining the laser cutting parameters. As shown in the image below, I initially used 60% maximum power, 55% minimum power, and a cutting speed of 70.

After testing these settings, I found that they were still too aggressive for cutting the synthetic leather. To improve the cut quality and avoid excessive burning of the material, I reduced the laser power to 35% maximum power and 30% minimum power, while increasing the cutting speed to 80. These adjustments produced cleaner cuts and improved the overall quality of the textile components.

Result of the fabrication of the textile components.

PCB Fabrication

After completing the mechanical and textile components, I proceeded with the fabrication of the PCB for my device. For this process, I used the Xtool laser machine, which allowed me to engrave and manufacture copper-clad circuit boards.

During the Electronics Production week, I documented the parameters used for PCB fabrication in detail. I also carried out several tests and iterations to determine the most suitable settings for achieving reliable traces and good manufacturing quality. I invite you to review that week's documentation to learn more about the process and the experiments that were performed.

Final result of the manufactured PCB.

Assembly

Once the PCB had been successfully fabricated, I proceeded with the assembly stage of the project. The assembly process began with the textile components, which were sewn and prepared to integrate the electronic and structural parts of the device.

To manufacture and assemble the textile elements, I used a Brother SE1900 sewing and embroidery machine. This machine allowed me to join the different fabric pieces accurately and create the wearable structure required for the project. The assembly process is shown in the following video.

The next step was to join the PETG printed parts with the synthetic leather structure. To achieve this, I used mesh fabric as an intermediate material and Weld-On adhesive to create a strong and durable bond between the textile and plastic components. In the System Integration week, I explain the assembly process in greater detail and describe the techniques used to integrate the different materials.

After completing the structural assembly, I prepared and routed the wiring for the flex sensors. Each sensor was connected using custom-made cables while maintaining flexibility and comfort during hand movements. Care was taken to organize the wiring neatly to prevent interference with the user's natural finger motion.

The following image shows how the flex sensors are positioned within the device. Note: The flex sensors are connected directly to the PCB without the need for intermediate connector boards.

Once the assembly process was completed, the device should look as shown in the image below.

As can be seen, I used hook-and-loop fabric (Velcro) to secure and organize the remaining loose components. Using this fastening method allows easy access to the flex sensor wiring for maintenance, adjustments, or future modifications without having to permanently disassemble the device.

After reaching this stage, I began the programming phase of both the glove and the graphical user interface that had been designed previously. This involved implementing the communication between the ESP32-C3 and the computer, processing the flex sensor data, recognizing gestures, and displaying the corresponding words or letters through the custom software interface.

Programming

To program the device, two separate software applications were developed. The first program runs on the custom PCB and is responsible for reading the flex sensor values, processing the finger positions, recognizing gestures, and transmitting the detected information wirelessly through the XIAO ESP32-C3 module. The second program is the graphical user interface (GUI), which runs on a computer and manages communication with the device while displaying the detected words and letters to the user.

Communication between the glove and the computer is established through a Wi-Fi connection. The ESP32-C3 sends information related to gesture selection, calibration status, and confirmed words or letters, while the graphical interface can send commands back to the device, such as calibration requests and operating mode changes.

In the following sections, I will first explain the general logic of the firmware running on the fabricated PCB, including sensor calibration, gesture recognition, and wireless communication. After that, I will describe the graphical user interface software, explaining how it receives data from the glove, manages calibration procedures, and displays the information to the user.

Logic in ESP32C3

The communication glove is based on three flex sensors connected to a XIAO ESP32-C3. The system converts finger bending positions into predefined words or letters and sends the selected information wirelessly to a graphical user interface running on a computer.

1. WiFi Communication

When the ESP32-C3 starts, it connects to the local WiFi network and establishes a TCP connection with the computer.

WiFi.begin(ssid, password);
client.connect(host, port);

This communication channel is used to:

• Receive commands from the graphical interface.
• Send calibration messages.
• Send selected words or letters.

2. Automatic Sensor Calibration

Before using the glove, a calibration process is executed. The user first opens the hand completely and the system stores the analog values of each flex sensor. Then, the user closes the hand completely and a second set of values is recorded.

To improve stability and reduce noise, the system calculates the average of 100 sensor readings for each finger position.

promedioSensor()

These values are later used as the reference points for angle calculation.

3. Angle Calculation

After calibration, each sensor reading is converted into an angle between 0° and 90°.

float angulo = map(valor, 0, valorm, 0, 90);

• 0° = Fully extended finger
• 90° = Fully bent finger

This normalization allows the glove to adapt to different users without modifying the source code.

4. Gesture Classification

Each finger position is classified into one of three states according to the calculated angle.

State	Angle Range
RECTO	0° – 30°
MEDIO	35° – 70°
DOBLADO	75° – 90°

The function responsible for this classification is:

verificarEstadoSensor()

5. Gesture Recognition

The glove uses three flex sensors located on the index, middle, and ring fingers. Each finger can have three possible states:

• RECTO
• MEDIO
• DOBLADO

This creates a total of 27 possible gesture combinations.

The function buscarGesto() compares the detected combination against a predefined lookup table containing words or letters.

{"RECTO","RECTO","RECTO","HELLO"}

If a match is found, the corresponding word or letter is selected.

6. Word Mode

In word mode, each gesture corresponds to a complete word commonly used for daily communication.

Gesture	Output
RECTO - RECTO - RECTO	HELLO
RECTO - MEDIO - MEDIO	THANK YOU
MEDIO - DOBLADO - MEDIO	MEDICINE

7. Letter Mode

The same gesture combinations can also represent alphabet letters.

Gesture	Letter
RECTO - RECTO - RECTO	A
RECTO - RECTO - MEDIO	B
RECTO - RECTO - DOBLADO	C

The user can switch between word mode and letter mode from the graphical interface.

MODO:PALABRA
MODO:LETRA

8. Selection Mechanism

When a gesture is recognized, the corresponding word or letter is stored as the current selection.

palabraSeleccionada

The selected item is transmitted to the graphical interface using:

SEL:HELLO
SEL:A

This allows the user to preview the selected content before sending it.

9. Transmission Mechanism

To avoid accidental transmissions, the glove uses a closed fist as a confirmation gesture.

The function esPunoCerrado() verifies whether all fingers are in the DOBLADO state.

DOBLADO
DOBLADO
DOBLADO

When this gesture is detected, the selected word or letter is sent to the computer.

SEND:HELLO
SEND:A

10. Human-Machine Interface

The desktop application receives messages from the ESP32-C3 and displays:

• Calibration status.
• Current operating mode.
• Selected word or letter.
• Transmitted words and letters.

Communication is performed through TCP sockets over WiFi, enabling real-time interaction between the wearable device and the graphical interface.

System Workflow

1. ESP32 connects to the WiFi network.
2. User starts the calibration process.
3. Open-hand sensor values are recorded.
4. Closed-hand sensor values are recorded.
5. Sensor readings are converted into angles.
6. Angles are classified as RECTO, MEDIO, or DOBLADO.
7. The gesture is matched with a word or letter.
8. The selected content is displayed in the interface.
9. A closed fist confirms the selection.
10. The ESP32 sends the final result to the computer.

This architecture creates a low-cost wearable communication system capable of translating hand gestures into words and letters in real time.

Qt Designer Graphical Interface

Next, I programmed the graphical user interface that had been designed previously using Qt Designer. This software allows the interface layout to be created visually and saved as a .ui file containing all the graphical elements and their properties.

To use the interface within the Python application, the .ui file must be converted into a Python file. This conversion was performed using the command shown in the image below.

Once the conversion process is completed, Qt generates a Python file containing all the code required to create the graphical interface. This file can then be imported into the main application, allowing additional functionality to be programmed and integrated with the wearable device.

After generating the Python file, it becomes possible to modify and extend the application by adding communication routines, calibration controls, gesture visualization, and data processing functions. This approach separates the visual design from the application logic, making the software easier to develop, maintain, and update as the project evolves.

The graphical user interface (GUI) was developed using PyQt6 and acts as the communication bridge between the ESP32-C3 glove and the user. Its main function is to receive the detected gestures, display the selected words or letters, perform the calibration process, and build complete sentences.

1. TCP Server Initialization

The application creates a TCP server using Python sockets and waits for a connection from the ESP32-C3.

server.bind((HOST, PORT))
server.listen()
self.client, addr = server.accept()

Once connected, the computer continuously receives data sent by the glove through WiFi.

2. Multithreaded Communication

To avoid freezing the graphical interface while waiting for incoming data, a secondary thread is created.

self.hilo = Thread(
    target=self.receptor.iniciar,
    daemon=True
)

This thread continuously listens for messages coming from the ESP32-C3 while the main thread remains responsible for updating the interface.

3. Signal-Based Architecture

The communication between the reception thread and the graphical interface is implemented using PyQt signals.

palabra_seleccionada
palabra_enviada
calibracion_signal

This architecture guarantees safe communication between threads and prevents interface crashes.

4. Receiving Messages

The ESP32-C3 sends three different message types:

Prefix	Function
SEL:	Selected word or letter preview
SEND:	Confirmed word or letter
CAL:	Calibration status messages

When a message arrives, the corresponding signal is emitted and processed by the GUI.

5. Calibration System

The calibration process is initiated by pressing the calibration button.

self.ui.btnCalibration.clicked.connect(
    self.calibarGuante
)

The GUI sends the command:

CALIBRAR

to the ESP32-C3 and waits for status updates.

The ESP32 informs the interface when the user must:

• Open the hand completely.
• Close the hand completely.

Two progress bars visually indicate the calibration progress.

6. Progress Bar Control

A QTimer object updates the calibration bars every second.

self.timer.timeout.connect(
    self.actualizar_progreso
)

The progress percentage is calculated as:

progreso =
(tiempo_actual / tiempo_total) × 100

Once the timer reaches the predefined calibration duration, the progress bar reaches 100%.

7. Operating Modes

The interface supports two operating modes:

• Word Mode
• Alphabet Mode

When a mode button is pressed, the GUI sends:

MODO:PALABRA

or

MODO:LETRA

to the ESP32-C3.

The selected button is highlighted to indicate the active mode.

8. Gesture Preview

Before confirming a gesture, the ESP32 sends a preview message:

SEL:HELLO

The interface displays the detected word or letter so the user can verify the selection before transmitting it.

9. Sentence Generation

When the user performs the confirmation gesture, the ESP32 sends:

SEND:HELLO

or

SEND:A

The interface then appends the received information to the generated sentence.

self.oracion1 += texto

In Word Mode, complete words are added. In Alphabet Mode, individual letters are concatenated to form custom words and sentences.

10. Reset Function

The reset button clears all generated content and restores the interface to its initial state.

self.oracion1 = ""

This allows the user to start a new sentence of words

System Workflow

1. The GUI starts a TCP server.
2. The ESP32-C3 connects through WiFi.
3. The user calibrates the glove.
4. Flex sensor data is processed by the ESP32.
5. The ESP32 sends gesture information.
6. The GUI displays the selected word or letter.
7. The user confirms the gesture.
8. The final text is added to the generated sentence.
9. The interface displays the complete communication output.

This graphical interface transforms the glove into a real-time communication system capable of translating hand gestures into words, letters, and complete sentences.

Once I reached this stage, I began testing the device to verify its functionality, as shown below.

As shown in the previous video, the device is capable of transmitting information wirelessly, allowing the words generated by specific finger gesture combinations to be displayed on the graphical user interface. At the same time, the interface successfully receives and interprets this information, presenting it on the screen in real time.

In this demonstration, I am generating the phrase HELP DOCTOR, which can be interpreted as a request for medical assistance. These words are part of a predefined vocabulary, where each word is associated with a specific finger gesture. By combining different gestures, it is possible to create short phrases that convey meaningful information and context, such as HELP DOCTOR.

NOTE: On the right side of the graphical interface there are two buttons, one orange and one light blue. These buttons correspond to the operating modes of the device. The system currently includes two modes: Letter Mode (alphabet) and Word Mode (predefined words). At the moment, switching between modes requires clicking one of these buttons, which may be inconvenient for some users. To improve accessibility, I am currently developing a dedicated gesture that will allow the user to switch between Letter Mode and Word Mode directly from the glove, eliminating the need to manually press the buttons each time a mode change is required.

As shown in the previous video, I am generating the phrase FOOD PLEASE. Depending on the situation, this phrase may be interpreted as "I would like some food" or "Please give me food." Although the phrase is short, it successfully communicates a clear message, demonstrating how predefined gestures can be combined to express basic needs and intentions.

In the last video shown, it is possible to observe how I can generate a short farewell phrase such as BYE FRIEND.

After conducting these tests, I identified several areas for improvement. One of the main issues was that the flex sensors were affected by electrical noise generated by the XIAO ESP32-C3. To address this, I improved the software by implementing additional filtering techniques to reduce noise and obtain more reliable ADC readings. These improvements resulted in more accurate gesture detection and increased system stability. In addition, I implemented a gesture-based mode switching system, allowing users to switch between Letter Mode and Word Mode without interacting directly with the graphical interface.

The following video demonstrates the system after these improvements were implemented.

As shown in the video, the graphical interface first indicates that the device is successfully connected. Before using the system, the device must be calibrated. To begin the calibration process, I press the Start Calibration button. After pressing the button, I keep my hand open as shown in the video. When the interface prompts me to close my hand, I do so and maintain the closed position until both progress bars reach 100%.

Once both progress bars are completed, the device is considered calibrated. If the calibration is not performed correctly, the system displays a warning message indicating that the ADC ranges are invalid. This verification step ensures that the flex sensors operate within the expected measurement range and improves the reliability of gesture recognition.

After calibration, the user can begin selecting letters and words to create short phrases. The generated text is displayed in the lower text box located next to the Reset button.

In the demonstration video, I generate the phrase HI HELP, which can be interpreted as "Hello, help me." The word HI is not included in the predefined word vocabulary, while HELP is available in the predefined word list. Therefore, to create this phrase I use both operating modes.

First, I use Letter Mode to generate the word HI one letter at a time. Then, to switch to Word Mode, I keep my hand closed for approximately four seconds. During this period, a progress bar gradually fills until it reaches 100%, as shown in the video. Once completed, the interface displays a green message indicating that Word Mode is active. At this point, I can select any of the available predefined words. In this demonstration, I select the word HELP!.

Finally, the Reset button clears the current phrase, allowing the user to start creating a new message from the beginning.

Dowload File

Slide Video